import { defineStore } from 'pinia'
import { invoke } from '@tauri-apps/api/core'

export const useDatasetStore = defineStore('dataset', {
  state: () => ({
    // 当前数据集
    currentDataset: {
      id: null,
      name: '',
      filePath: '',
      data: [], // ShareGPT格式的数据数组
      isModified: false,
      lastSaved: null
    },
    
    // 最近打开的数据集列表
    recentDatasets: [],
    
    // 应用设置
    settings: {
      autoSave: true,
      autoSaveInterval: 300000, // 5分钟
      validateOnSave: true
    }
  }),

  getters: {
    // 获取数据集统计信息
    datasetStats: (state) => {
      if (!state.currentDataset.data) return null
      
      const conversations = state.currentDataset.data
      const totalConversations = conversations.length
      let totalMessages = 0
      let roleStats = {
        human: 0,
        thinking: 0,
        function_call: 0,
        observation: 0,
        gpt: 0
      }
      
      conversations.forEach(conv => {
        if (conv.conversations) {
          totalMessages += conv.conversations.length
          conv.conversations.forEach(msg => {
            if (roleStats[msg.from] !== undefined) {
              roleStats[msg.from]++
            }
          })
        }
      })
      
      return {
        totalConversations,
        totalMessages,
        roleStats,
        hasTools: conversations.some(conv => conv.tools),
        hasSystem: conversations.some(conv => conv.system)
      }
    },

    // 检查数据集是否有未保存的更改
    hasUnsavedChanges: (state) => state.currentDataset.isModified,

    // 检查数据集是否为空
    isEmpty: (state) => !state.currentDataset.data || state.currentDataset.data.length === 0
  },

  actions: {
    // 创建新数据集
    createDataset(name = '新建数据集') {
      this.currentDataset = {
        id: Date.now().toString(),
        name,
        filePath: '',
        data: [],
        isModified: true,
        lastSaved: null
      }
    },

    // 加载数据集
    async loadDataset(filePath) {
      try {
        const jsonData = await invoke('load_dataset', { path: filePath })
        const data = JSON.parse(jsonData)
        
        // 处理新格式（包含名称信息）和旧格式（不包含名称信息）
        let datasetName, conversations
        
        if (data.datasetName && data.conversations) {
          // 新格式：包含名称信息
          datasetName = data.datasetName
          conversations = data.conversations
        } else if (Array.isArray(data)) {
          // 旧格式：直接是对话数组
          datasetName = this.extractNameFromPath(filePath)
          conversations = data
        } else {
          // 旧格式：单个对话对象
          datasetName = this.extractNameFromPath(filePath)
          conversations = [data]
        }
        
        // 为没有名称的对话添加默认名称
        conversations.forEach((conv, index) => {
          if (!conv.name) {
            conv.name = `对话 ${index + 1}`
          }
        })
        
        this.currentDataset = {
          id: Date.now().toString(),
          name: datasetName,
          filePath,
          data: conversations,
          isModified: false,
          lastSaved: new Date()
        }
        
        this.addToRecentDatasets(filePath)
        return true
      } catch (error) {
        console.error('加载数据集失败:', error)
        throw new Error(`加载数据集失败: ${error}`)
      }
    },

    // 保存数据集
    async saveDataset(filePath) {
      try {
        const saveToPath = filePath || this.currentDataset.filePath
        if (!saveToPath) {
          throw new Error('请先选择保存位置')
        }

        // 保存时包含名称信息（内部格式）
        const saveData = {
          datasetName: this.currentDataset.name,
          conversations: this.currentDataset.data
        }
        
        const jsonData = JSON.stringify(saveData, null, 2)
        
        await invoke('save_dataset', { 
          path: saveToPath, 
          data: jsonData 
        })
        
        this.currentDataset.filePath = saveToPath
        this.currentDataset.isModified = false
        this.currentDataset.lastSaved = new Date()
        
        this.addToRecentDatasets(saveToPath)
        return true
      } catch (error) {
        console.error('保存数据集失败:', error)
        throw new Error(`保存数据集失败: ${error}`)
      }
    },

    // 添加新的对话记录
    addConversation(conversation = null) {
      const newConversation = conversation || {
        name: `对话 ${this.currentDataset.data.length + 1}`,
        conversations: [
          { from: 'human', value: '' },
          { from: 'gpt', value: '' }
        ],
        system: '',
        tools: ''
      }
      
      this.currentDataset.data.push(newConversation)
      this.currentDataset.isModified = true
    },

    // 删除对话记录
    removeConversation(index) {
      if (index >= 0 && index < this.currentDataset.data.length) {
        this.currentDataset.data.splice(index, 1)
        this.currentDataset.isModified = true
      }
    },

    // 更新对话记录
    updateConversation(index, conversation) {
      if (index >= 0 && index < this.currentDataset.data.length) {
        this.currentDataset.data[index] = { ...conversation }
        this.currentDataset.isModified = true
      }
    },

    // 更新数据集名称
    updateDatasetName(newName) {
      this.currentDataset.name = newName
      this.currentDataset.isModified = true
    },

    // 更新对话名称
    updateConversationName(index, newName) {
      if (index >= 0 && index < this.currentDataset.data.length) {
        this.currentDataset.data[index].name = newName
        this.currentDataset.isModified = true
      }
    },

    // 标记数据集为已修改
    markAsModified() {
      this.currentDataset.isModified = true
    },

    // 验证数据集格式
    async validateDataset() {
      try {
        const jsonData = JSON.stringify(this.currentDataset.data)
        const result = await invoke('validate_dataset', { data: jsonData })
        return result
      } catch (error) {
        console.error('验证数据集失败:', error)
        return { isValid: false, errors: [error.toString()] }
      }
    },

    // 工具函数：从文件路径提取文件名
    extractNameFromPath(filePath) {
      return filePath.split(/[/\\]/).pop().replace(/\.[^/.]+$/, '') || '未命名数据集'
    },

    // 添加到最近打开列表
    addToRecentDatasets(filePath) {
      const existing = this.recentDatasets.findIndex(item => item.path === filePath)
      if (existing !== -1) {
        this.recentDatasets.splice(existing, 1)
      }
      
      this.recentDatasets.unshift({
        path: filePath,
        name: this.extractNameFromPath(filePath),
        lastOpened: new Date()
      })
      
      // 只保留最近10个
      if (this.recentDatasets.length > 10) {
        this.recentDatasets = this.recentDatasets.slice(0, 10)
      }
    },

    // 清空当前数据集
    clearDataset() {
      this.currentDataset = {
        id: null,
        name: '',
        filePath: '',
        data: [],
        isModified: false,
        lastSaved: null
      }
    },

    // 合并数据集
    async mergeDatasets(filePaths) {
      if (!Array.isArray(filePaths) || filePaths.length === 0) {
        throw new Error('请选择要合并的数据集文件')
      }

      try {
        const datasets = []
        
        // 加载所有数据集
        for (const filePath of filePaths) {
          const jsonData = await invoke('load_dataset', { path: filePath })
          const data = JSON.parse(jsonData)
          
          // 处理新格式和旧格式
          let conversations
          if (data.datasetName && data.conversations) {
            conversations = data.conversations
          } else if (Array.isArray(data)) {
            conversations = data
          } else {
            conversations = [data]
          }
          
          datasets.push({
            data: conversations,
            filePath
          })
        }

        // 如果当前没有数据集，创建一个新的
        if (!this.currentDataset.data) {
          this.createDataset('合并数据集')
        }

        // 合并所有对话数据
        let totalConversations = 0
        for (const dataset of datasets) {
          if (dataset.data && Array.isArray(dataset.data)) {
            // 为没有名称的对话添加默认名称
            dataset.data.forEach((conv, index) => {
              if (!conv.name) {
                conv.name = `导入对话 ${this.currentDataset.data.length + index + 1}`
              }
            })
            
            this.currentDataset.data.push(...dataset.data)
            totalConversations += dataset.data.length
          }
        }

        this.currentDataset.isModified = true
        this.currentDataset.name = `合并数据集_${new Date().toISOString().slice(0, 10)}`
        
        return {
          success: true,
          message: `成功合并 ${datasets.length} 个数据集，总计 ${totalConversations} 个对话`
        }
      } catch (error) {
        console.error('合并数据集失败:', error)
        throw new Error(`合并数据集失败: ${error.message}`)
      }
    },

    // 导入数据集（追加到当前数据集）
    async importDataset(filePath) {
      try {
        const jsonData = await invoke('load_dataset', { path: filePath })
        const data = JSON.parse(jsonData)
        
        // 处理新格式和旧格式
        let importData
        if (data.datasetName && data.conversations) {
          importData = data.conversations
        } else if (Array.isArray(data)) {
          importData = data
        } else {
          importData = [data]
        }
        
        // 如果当前没有数据集，创建一个新的
        if (!this.currentDataset.data) {
          this.createDataset('导入数据集')
        }
        
        // 导入前的对话数量
        const beforeCount = this.currentDataset.data.length
        
        // 为没有名称的对话添加默认名称
        importData.forEach((conv, index) => {
          if (!conv.name) {
            conv.name = `导入对话 ${beforeCount + index + 1}`
          }
        })
        
        // 追加到当前数据集
        this.currentDataset.data.push(...importData)
        this.currentDataset.isModified = true
        
        const importedCount = importData.length
        
        return {
          success: true,
          message: `成功导入 ${importedCount} 个对话，当前数据集共有 ${this.currentDataset.data.length} 个对话`
        }
      } catch (error) {
        console.error('导入数据集失败:', error)
        throw new Error(`导入数据集失败: ${error.message}`)
      }
    },

    // 导出数据集
    async exportDataset(filePath) {
      try {
        if (!this.currentDataset.data || this.currentDataset.data.length === 0) {
          throw new Error('当前数据集为空，无法导出')
        }

        // 确保导出的数据符合ShareGPT格式
        const exportData = this.normalizeShareGPTFormat(this.currentDataset.data)
        
        const jsonData = JSON.stringify(exportData, null, 2)
        await invoke('save_dataset', { 
          path: filePath, 
          data: jsonData 
        })
        
        return true
      } catch (error) {
        console.error('导出数据集失败:', error)
        throw new Error(`导出数据集失败: ${error.message}`)
      }
    },

    // 规范化ShareGPT格式
    normalizeShareGPTFormat(data) {
      return data.map(conversation => {
        const normalized = {
          conversations: conversation.conversations || []
        }
        
        // 添加系统提示词（如果存在）
        if (conversation.system && conversation.system.trim()) {
          normalized.system = conversation.system
        }
        
        // 处理工具定义
        if (conversation.tools && conversation.tools.trim()) {
          try {
            const tools = JSON.parse(conversation.tools)
            if (Array.isArray(tools) && tools.length > 0) {
              // 转换为标准ShareGPT工具格式
              normalized.tools = tools.map(tool => ({
                type: 'function',
                function: {
                  name: tool.name,
                  description: tool.description,
                  parameters: tool.parameters || {}
                }
              }))
            }
          } catch (e) {
            console.warn('工具定义格式错误，跳过:', e)
          }
        }
        
        return normalized
      }).filter(conv => conv.conversations && conv.conversations.length > 0)
    }
  }
}) 